#include "reg_mod_orden.h"
#include "ui_reg_mod_orden.h"
#include <Entidades/perfil_analisis.h>

Reg_mod_orden::Reg_mod_orden(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::Reg_mod_orden)
{
    ui->setupUi(this);
    this->setWindowTitle("Registrar Orden");

    QDjango::setDebugEnabled(true);
    ui->medicoLabel->setVisible(false);

    QDjangoQuerySet<Paciente> pacientes;
    QDjangoQuerySet<Medico> medicos;
    QDjangoQuerySet<Seguro> seguros;
    QStringList *listaPaciente = new QStringList();
    QStringList *listaMedico   = new QStringList();
    QStringList *listaSeguros  = new QStringList();

    if(pacientes.count() > 0)
        foreach (const Paciente &pac, pacientes){listaPaciente->append(QString::number(pac.getCedula()));}

    if(medicos.count() > 0)
        foreach (const Medico &med, medicos){listaMedico->append(QString::number(med.getNum_registro()));}

    if(seguros.count() > 0)
        foreach (const Seguro &seg, seguros){listaSeguros->append(seg.getNombre());}

    QCompleter* completarCedula  = new QCompleter(*listaPaciente);
    QCompleter* completarNumero  = new QCompleter(*listaMedico);
    QCompleter* completarSeguro  = new QCompleter(*listaSeguros);

    ui->cedulaEdit->setCompleter(completarCedula);
    ui->medicoEdit->setCompleter(completarNumero);
    ui->widgetNuevoPerfil->setVisible(false);
    /**LineEdit de Seguro**/
    ui->seguroLineEdit->setCompleter(completarSeguro);
    //this->setWindowFlags(Qt::Tool | Qt::WindowContextHelpButtonHint);

    QDjangoQuerySet<Origen> origenes;
    if(origenes.count() > 0)
        foreach (const Origen &origen,origenes){ui->origenComboBox->addItem(origen.getNombre());}


    if(perfiles.count() > 0 )
        foreach(const Perfil &perfil, perfiles){
            ui->listPerfilesPerfiles->addItem(perfil.getNombre());
        }
    if(todosAnalisis.count() > 0)
        foreach (const Analisis &analisis, todosAnalisis) {
            ui->listAnalisisAnalisis->addItem(analisis.getNombre());
        }

    /*StringLists para inserciones en la tabla general de analisis y una tabla de todos los
    Analisis solicitados(Perfiles y analisis individuales) */
    listaAnalisisOrden = new QStringList();
    listaPerfilesOrden = new QStringList();
    listaGeneralAnalisis = new QList<Analisis *>();
    listaAnalisis_ana_perf = new QStringList();
}

Reg_mod_orden::~Reg_mod_orden()
{
    delete ui;
}

void Reg_mod_orden::on_botonAceptar_clicked()
{

    QSqlQuery query;
    query.exec("select coalesce(max(nro_orden),0) from orden");
    int maxId;

    while (query.next())
    {
        maxId = query.value(0).toInt();
    }

    QDjangoQuerySet<Paciente> pacientes;
    Paciente *pac = pacientes.filter(QDjangoWhere("cedula", QDjangoWhere::Equals, ui->cedulaEdit->text())).at(0);

    QDjangoQuerySet<Medico> medicos;
    Medico  *med  = medicos.filter(QDjangoWhere("num_registro", QDjangoWhere::Equals, ui->medicoEdit->text())).at(0);

    QDjangoQuerySet<Seguro> seguros;
    Seguro  *seg  = seguros.filter(QDjangoWhere("nombre",QDjangoWhere::Equals,ui->seguroLineEdit->text())).at(0);

    QDjangoQuerySet<Origen> origenes;
    Origen  *orig = origenes.filter(QDjangoWhere("nombre",QDjangoWhere::Equals,ui->origenComboBox->currentText())).at(0);

    QDjangoQuerySet<Estado> estados;
    Estado  *estado  = estados.filter(QDjangoWhere("descripcion",QDjangoWhere::Equals,"preingresada")).at(0);

    Orden *orden = new Orden();

    orden->setNro_orden(maxId + 1);
    orden->setPaciente(pac);
    orden->setMedico(med);
    orden->setSeguro(seg);
    orden->setPrioridad(ui->urgenciaComboBox->currentText());
    orden->setFecha_recibida(QDate::currentDate());
    orden->setFecha_compromiso(ui->dateEditFechaCompromiso->date());
    orden->setOrigen(orig);
    orden->setEstado(estado);

    QDjangoQuerySet<Sucursal> sucursales;
    orden->setSucursal(sucursales.at(0));

    orden->save();
    cuadroMensaje("Éxito", "Orden registrada");
    this->close();
}

void Reg_mod_orden::on_botonCancelar_clicked()
{
    this->close();
}

void Reg_mod_orden::on_botonConsultarPaciente_clicked()
{
    Consultar_paciente *consultarPaciente = new Consultar_paciente();
    consultarPaciente->exec();
    delete consultarPaciente;
}

void Reg_mod_orden::on_botonConsultarMedico_clicked()
{
    ConsultaMedico *consultarMedico = new ConsultaMedico();
    consultarMedico->exec();
    delete consultarMedico;
}

void Reg_mod_orden::keyPressEvent(QKeyEvent *evento)
{
    if (evento->Enter)
    {
        if (ui->cedulaEdit->hasFocus())
        {
            QDjangoQuerySet<Paciente> pacientes;
            Paciente *paciente = pacientes.filter(QDjangoWhere("cedula", QDjangoWhere::Equals, ui->cedulaEdit->text())).at(0);
            ui->nombreLineEdit->setText(paciente->getNombre_completo());
            ui->direccionLineEdit->setText(paciente->getDireccion());
            ui->telefonoLineEdit->setText(paciente->getTelefono());
        }

        if (ui->medicoEdit->hasFocus())
        {
            QDjangoQuerySet<Medico> medicos;
            Medico *medico = medicos.filter(QDjangoWhere("num_registro", QDjangoWhere::Equals, ui->medicoEdit->text())).at(0);
            ui->medicoLabel->setText(medico->getNombre() + " " + medico->getApellido());
            ui->medicoLabel->setVisible(true);
        }
    }
}


void Reg_mod_orden::on_medicoEdit_textChanged()
{
    if(ui->medicoLabel->isVisible())ui->medicoLabel->setVisible(false);
}



void Reg_mod_orden::on_listAnalisisAnalisis_itemSelectionChanged()
{
    ui->listDeterminaciones->clear();
    QModelIndex selectedIndex = ui->listAnalisisAnalisis->selectionModel()->selectedRows().at(0);
    QString nombreAnalisis = ui->listAnalisisAnalisis->model()->data(selectedIndex).toString();
    Analisis *analisisSeleccionado = todosAnalisis.filter(QDjangoWhere("nombre", QDjangoWhere::Equals, nombreAnalisis)).at(0);

    QDjangoQuerySet<Ana_Det> anadet;
    anadet = anadet.filter(QDjangoWhere("analisis_id", QDjangoWhere::Equals, analisisSeleccionado->getId_analisis()));

    if(anadet.count() > 0)
    foreach(const Ana_Det &ad, anadet){
        Determinacion *det = determinaciones.filter(QDjangoWhere("id_determinacion", QDjangoWhere::Equals, ad.getDeterminacion()->getId_determinacion())).at(0);
        ui->listDeterminaciones->addItem(det->getNombre());
        delete det;
    }
    delete analisisSeleccionado;
}

void Reg_mod_orden::on_listPerfilesPerfiles_itemSelectionChanged()
{
    ui->listPerfilesAnalisis->clear();
    QModelIndex selectedIndex = ui->listPerfilesPerfiles->selectionModel()->selectedRows().at(0);
    QString nombrePerfil = ui->listPerfilesPerfiles->model()->data(selectedIndex).toString();
    Perfil *perfilSeleccionado = perfiles.filter(QDjangoWhere("nombre", QDjangoWhere::Equals, nombrePerfil)).at(0);

    qDebug() << "Nombre perfil : " + perfilSeleccionado->getNombre();

    QDjangoQuerySet<Perfil_Analisis> perfiles_analisis;
    perfiles_analisis = perfiles_analisis.filter(QDjangoWhere("perfil_id", QDjangoWhere::Equals, perfilSeleccionado->getId_perfil()));
    qDebug() << "Cantidad perf_an encontrados : " + QString::number(perfiles_analisis.count());

    if(perfiles_analisis.count() > 0)
        foreach(const Perfil_Analisis &pa, perfiles_analisis){
            Analisis *a = todosAnalisis.filter(QDjangoWhere("id_analisis", QDjangoWhere::Equals, pa.getAnalisis()->getId_analisis())).at(0);
            ui->listPerfilesAnalisis->addItem(a->getNombre());
            delete a;
        }
    delete perfilSeleccionado;
}


void Reg_mod_orden::on_agregar_clicked()
{
    int indiceTab = ui->tabWidget->currentIndex();
    QModelIndexList listaAnalisis = ui->listAnalisisAnalisis->selectionModel()->selectedRows();
    QModelIndexList listaPerfiles = ui->listPerfilesPerfiles->selectionModel()->selectedRows();

    if((indiceTab == 1 && listaAnalisis.count() != 1) || (indiceTab == 0 && listaPerfiles.count() != 1)) cuadroMensaje("Debe seleccionar un perfil o analisis para agregar a la lista", "");

    else
    {
        if(indiceTab == 0){

            QString nombre = ui->listPerfilesPerfiles->model()->data(listaPerfiles.at(0)).toString();
            Perfil *perfilSeleccionado = perfiles.filter(QDjangoWhere("nombre", QDjangoWhere::Equals, nombre)).at(0);

            //Se ve si el perfil ya esta en la lista general, sino se inserta
            if(!listaPerfilesOrden->contains(perfilSeleccionado->getNombre()))
            {
                listaPerfilesOrden->append(perfilSeleccionado->getNombre());
                ui->listTodos->addItem(perfilSeleccionado->getNombre());
            }

            //Por cada analisis en el perfil se ingresa en la lista final, se omite si ya existe
            QDjangoQuerySet<Perfil_Analisis> perf_an = perfiles_analisis.filter(QDjangoWhere("perfil_id", QDjangoWhere::Equals, perfilSeleccionado->getId_perfil()));
            if(perf_an.count() > 0){
                int contAnalisisomitidos = 0;
                for (int i=0; i < perf_an.count(); i++){
                    Analisis *a = todosAnalisis.filter(QDjangoWhere("id_analisis", QDjangoWhere::Equals, perf_an.at(i)->getAnalisis()->getId_analisis())).at(0);
                    if(!listaAnalisis_ana_perf->contains(a->getNombre()))
                    {

                        qDebug() << "Insertando analisis en lista final";
                        listaGeneralAnalisis->append(a);
                        listaAnalisis_ana_perf->append(a->getNombre());
                    }
                    else{
                        contAnalisisomitidos++;
                    }
                    delete a;
                }
                qDebug() << "Se omiten " + QString::number(contAnalisisomitidos) +  " analisis";
            }
            delete perfilSeleccionado;
        }
        else if(indiceTab==1){
            QString nombreAnalisis = ui->listAnalisisAnalisis->model()->data(listaAnalisis.at(0)).toString();
            Analisis *analisis = todosAnalisis.filter(QDjangoWhere("nombre", QDjangoWhere::Equals, nombreAnalisis)).at(0);
            int contAnalisisomitidos= 0;

            //Comprobacion para meter en la tabla General
            if(!listaAnalisisOrden->contains(analisis->getNombre())){
                listaAnalisisOrden->append(analisis->getNombre());
                ui->listTodos->addItem(analisis->getNombre());
            }

            //Comprobacion para meter en la lista final de analisis a guardarse
            if(!listaAnalisis_ana_perf->contains(analisis->getNombre())){
                listaAnalisis_ana_perf->append(analisis->getNombre());
                listaGeneralAnalisis->append(analisis);
            }
            else contAnalisisomitidos++;
            qDebug() << "Se omiten " + QString::number(contAnalisisomitidos) + " analisis";

            delete analisis;
        }

    }
}

void Reg_mod_orden::on_buscar_perfiles_textChanged(const QString &arg1)
{
    ui->listAnalisisAnalisis->clearSelection();
 //   ui->listPerfilesPerfiles->clear();
    QDjangoQuerySet<Perfil> filtroPerfiles = perfiles.filter(QDjangoWhere("nombre", QDjangoWhere::IStartsWith, arg1));
    ui->listPerfilesPerfiles->clear();
    if(filtroPerfiles.count() > 0){
        foreach(const Perfil &p, filtroPerfiles) ui->listPerfilesPerfiles->addItem(p.getNombre());

    }
}


void Reg_mod_orden::on_buscar_analisis_textEdited(const QString &arg1)
{
    ui->listAnalisisAnalisis->clear();

    QDjangoQuerySet<Analisis> filtroAnalisis = todosAnalisis.filter(QDjangoWhere("nombre", QDjangoWhere::IStartsWith, arg1));

    if(filtroAnalisis.count() > 0){
        foreach(const Analisis &a, filtroAnalisis) ui->listAnalisisAnalisis->addItem(a.getNombre());

    }
}



void Reg_mod_orden::on_seguroPushButton_clicked()
{
    Consulta_seguro *ventanaSeguro = new Consulta_seguro();
    ventanaSeguro->exec();
    delete ventanaSeguro;
}
